// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
// the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
// an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by google-apis-code-generator 1.5.1
//     C# generator version: 1.22.0
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

/**
 * \brief
 *   Google Analytics Reporting API Version v4
 *
 * \section ApiInfo API Version Information
 *    <table>
 *      <tr><th>API
 *          <td><a href='https://developers.google.com/analytics/devguides/reporting/core/v4/'>Google Analytics Reporting API</a>
 *      <tr><th>API Version<td>v4
 *      <tr><th>API Rev<td>20170309 (798)
 *      <tr><th>API Docs
 *          <td><a href='https://developers.google.com/analytics/devguides/reporting/core/v4/'>
 *              https://developers.google.com/analytics/devguides/reporting/core/v4/</a>
 *      <tr><th>Discovery Name<td>analyticsreporting
 *    </table>
 *
 * \section ForMoreInfo For More Information
 *
 * The complete API documentation for using Google Analytics Reporting API can be found at
 * <a href='https://developers.google.com/analytics/devguides/reporting/core/v4/'>https://developers.google.com/analytics/devguides/reporting/core/v4/</a>.
 *
 * For more information about the Google APIs Client Library for .NET, see
 * <a href='https://developers.google.com/api-client-library/dotnet/get_started'>
 * https://developers.google.com/api-client-library/dotnet/get_started</a>
 */

namespace Google.Apis.AnalyticsReporting.v4
{
    /// <summary>The AnalyticsReporting Service.</summary>
    public class AnalyticsReportingService : Google.Apis.Services.BaseClientService
    {
        /// <summary>The API version.</summary>
        public const string Version = "v4";

        /// <summary>The discovery version used to generate this service.</summary>
        public static Google.Apis.Discovery.DiscoveryVersion DiscoveryVersionUsed =
            Google.Apis.Discovery.DiscoveryVersion.Version_1_0;

        /// <summary>Constructs a new service.</summary>
        public AnalyticsReportingService() :
            this(new Google.Apis.Services.BaseClientService.Initializer()) {}

        /// <summary>Constructs a new service.</summary>
        /// <param name="initializer">The service initializer.</param>
        public AnalyticsReportingService(Google.Apis.Services.BaseClientService.Initializer initializer)
            : base(initializer)
        {
            reports = new ReportsResource(this);
        }

        /// <summary>Gets the service supported features.</summary>
        public override System.Collections.Generic.IList<string> Features
        {
            get { return new string[0]; }
        }

        /// <summary>Gets the service name.</summary>
        public override string Name
        {
            get { return "analyticsreporting"; }
        }

        /// <summary>Gets the service base URI.</summary>
        public override string BaseUri
        {
            get { return "https://analyticsreporting.googleapis.com/"; }
        }

        /// <summary>Gets the service base path.</summary>
        public override string BasePath
        {
            get { return ""; }
        }

        /// <summary>Available OAuth 2.0 scopes for use with the Google Analytics Reporting API.</summary>
        public class Scope
        {
            /// <summary>View and manage your Google Analytics data</summary>
            public static string Analytics = "https://www.googleapis.com/auth/analytics";

            /// <summary>View your Google Analytics data</summary>
            public static string AnalyticsReadonly = "https://www.googleapis.com/auth/analytics.readonly";

        }



        private readonly ReportsResource reports;

        /// <summary>Gets the Reports resource.</summary>
        public virtual ReportsResource Reports
        {
            get { return reports; }
        }
    }

    ///<summary>A base abstract class for AnalyticsReporting requests.</summary>
    public abstract class AnalyticsReportingBaseServiceRequest<TResponse> : Google.Apis.Requests.ClientServiceRequest<TResponse>
    {
        ///<summary>Constructs a new AnalyticsReportingBaseServiceRequest instance.</summary>
        protected AnalyticsReportingBaseServiceRequest(Google.Apis.Services.IClientService service)
            : base(service)
        {
        }

        /// <summary>V1 error format.</summary>
        [Google.Apis.Util.RequestParameterAttribute("$.xgafv", Google.Apis.Util.RequestParameterType.Query)]
        public virtual System.Nullable<XgafvEnum> Xgafv { get; set; }

        /// <summary>V1 error format.</summary>
        public enum XgafvEnum
        {
            /// <summary>v1 error format</summary>
            [Google.Apis.Util.StringValueAttribute("1")]
            Value1,
            /// <summary>v2 error format</summary>
            [Google.Apis.Util.StringValueAttribute("2")]
            Value2,
        }

        /// <summary>OAuth access token.</summary>
        [Google.Apis.Util.RequestParameterAttribute("access_token", Google.Apis.Util.RequestParameterType.Query)]
        public virtual string AccessToken { get; set; }

        /// <summary>Data format for response.</summary>
        /// [default: json]
        [Google.Apis.Util.RequestParameterAttribute("alt", Google.Apis.Util.RequestParameterType.Query)]
        public virtual System.Nullable<AltEnum> Alt { get; set; }

        /// <summary>Data format for response.</summary>
        public enum AltEnum
        {
            /// <summary>Responses with Content-Type of application/json</summary>
            [Google.Apis.Util.StringValueAttribute("json")]
            Json,
            /// <summary>Media download with context-dependent Content-Type</summary>
            [Google.Apis.Util.StringValueAttribute("media")]
            Media,
            /// <summary>Responses with Content-Type of application/x-protobuf</summary>
            [Google.Apis.Util.StringValueAttribute("proto")]
            Proto,
        }

        /// <summary>OAuth bearer token.</summary>
        [Google.Apis.Util.RequestParameterAttribute("bearer_token", Google.Apis.Util.RequestParameterType.Query)]
        public virtual string BearerToken { get; set; }

        /// <summary>JSONP</summary>
        [Google.Apis.Util.RequestParameterAttribute("callback", Google.Apis.Util.RequestParameterType.Query)]
        public virtual string Callback { get; set; }

        /// <summary>Selector specifying which fields to include in a partial response.</summary>
        [Google.Apis.Util.RequestParameterAttribute("fields", Google.Apis.Util.RequestParameterType.Query)]
        public virtual string Fields { get; set; }

        /// <summary>API key. Your API key identifies your project and provides you with API access, quota, and reports.
        /// Required unless you provide an OAuth 2.0 token.</summary>
        [Google.Apis.Util.RequestParameterAttribute("key", Google.Apis.Util.RequestParameterType.Query)]
        public virtual string Key { get; set; }

        /// <summary>OAuth 2.0 token for the current user.</summary>
        [Google.Apis.Util.RequestParameterAttribute("oauth_token", Google.Apis.Util.RequestParameterType.Query)]
        public virtual string OauthToken { get; set; }

        /// <summary>Pretty-print response.</summary>
        /// [default: true]
        [Google.Apis.Util.RequestParameterAttribute("pp", Google.Apis.Util.RequestParameterType.Query)]
        public virtual System.Nullable<bool> Pp { get; set; }

        /// <summary>Returns response with indentations and line breaks.</summary>
        /// [default: true]
        [Google.Apis.Util.RequestParameterAttribute("prettyPrint", Google.Apis.Util.RequestParameterType.Query)]
        public virtual System.Nullable<bool> PrettyPrint { get; set; }

        /// <summary>Available to use for quota purposes for server-side applications. Can be any arbitrary string
        /// assigned to a user, but should not exceed 40 characters.</summary>
        [Google.Apis.Util.RequestParameterAttribute("quotaUser", Google.Apis.Util.RequestParameterType.Query)]
        public virtual string QuotaUser { get; set; }

        /// <summary>Legacy upload protocol for media (e.g. "media", "multipart").</summary>
        [Google.Apis.Util.RequestParameterAttribute("uploadType", Google.Apis.Util.RequestParameterType.Query)]
        public virtual string UploadType { get; set; }

        /// <summary>Upload protocol for media (e.g. "raw", "multipart").</summary>
        [Google.Apis.Util.RequestParameterAttribute("upload_protocol", Google.Apis.Util.RequestParameterType.Query)]
        public virtual string UploadProtocol { get; set; }

        /// <summary>Initializes AnalyticsReporting parameter list.</summary>
        protected override void InitParameters()
        {
            base.InitParameters();

            RequestParameters.Add(
                "$.xgafv", new Google.Apis.Discovery.Parameter
                {
                    Name = "$.xgafv",
                    IsRequired = false,
                    ParameterType = "query",
                    DefaultValue = null,
                    Pattern = null,
                });
            RequestParameters.Add(
                "access_token", new Google.Apis.Discovery.Parameter
                {
                    Name = "access_token",
                    IsRequired = false,
                    ParameterType = "query",
                    DefaultValue = null,
                    Pattern = null,
                });
            RequestParameters.Add(
                "alt", new Google.Apis.Discovery.Parameter
                {
                    Name = "alt",
                    IsRequired = false,
                    ParameterType = "query",
                    DefaultValue = "json",
                    Pattern = null,
                });
            RequestParameters.Add(
                "bearer_token", new Google.Apis.Discovery.Parameter
                {
                    Name = "bearer_token",
                    IsRequired = false,
                    ParameterType = "query",
                    DefaultValue = null,
                    Pattern = null,
                });
            RequestParameters.Add(
                "callback", new Google.Apis.Discovery.Parameter
                {
                    Name = "callback",
                    IsRequired = false,
                    ParameterType = "query",
                    DefaultValue = null,
                    Pattern = null,
                });
            RequestParameters.Add(
                "fields", new Google.Apis.Discovery.Parameter
                {
                    Name = "fields",
                    IsRequired = false,
                    ParameterType = "query",
                    DefaultValue = null,
                    Pattern = null,
                });
            RequestParameters.Add(
                "key", new Google.Apis.Discovery.Parameter
                {
                    Name = "key",
                    IsRequired = false,
                    ParameterType = "query",
                    DefaultValue = null,
                    Pattern = null,
                });
            RequestParameters.Add(
                "oauth_token", new Google.Apis.Discovery.Parameter
                {
                    Name = "oauth_token",
                    IsRequired = false,
                    ParameterType = "query",
                    DefaultValue = null,
                    Pattern = null,
                });
            RequestParameters.Add(
                "pp", new Google.Apis.Discovery.Parameter
                {
                    Name = "pp",
                    IsRequired = false,
                    ParameterType = "query",
                    DefaultValue = "true",
                    Pattern = null,
                });
            RequestParameters.Add(
                "prettyPrint", new Google.Apis.Discovery.Parameter
                {
                    Name = "prettyPrint",
                    IsRequired = false,
                    ParameterType = "query",
                    DefaultValue = "true",
                    Pattern = null,
                });
            RequestParameters.Add(
                "quotaUser", new Google.Apis.Discovery.Parameter
                {
                    Name = "quotaUser",
                    IsRequired = false,
                    ParameterType = "query",
                    DefaultValue = null,
                    Pattern = null,
                });
            RequestParameters.Add(
                "uploadType", new Google.Apis.Discovery.Parameter
                {
                    Name = "uploadType",
                    IsRequired = false,
                    ParameterType = "query",
                    DefaultValue = null,
                    Pattern = null,
                });
            RequestParameters.Add(
                "upload_protocol", new Google.Apis.Discovery.Parameter
                {
                    Name = "upload_protocol",
                    IsRequired = false,
                    ParameterType = "query",
                    DefaultValue = null,
                    Pattern = null,
                });
        }
    }

    /// <summary>The "reports" collection of methods.</summary>
    public class ReportsResource
    {
        private const string Resource = "reports";

        /// <summary>The service which this resource belongs to.</summary>
        private readonly Google.Apis.Services.IClientService service;

        /// <summary>Constructs a new resource.</summary>
        public ReportsResource(Google.Apis.Services.IClientService service)
        {
            this.service = service;

        }


        /// <summary>Returns the Analytics data.</summary>
        /// <param name="body">The body of the request.</param>
        public virtual BatchGetRequest BatchGet(Google.Apis.AnalyticsReporting.v4.Data.GetReportsRequest body)
        {
            return new BatchGetRequest(service, body);
        }

        /// <summary>Returns the Analytics data.</summary>
        public class BatchGetRequest : AnalyticsReportingBaseServiceRequest<Google.Apis.AnalyticsReporting.v4.Data.GetReportsResponse>
        {
            /// <summary>Constructs a new BatchGet request.</summary>
            public BatchGetRequest(Google.Apis.Services.IClientService service, Google.Apis.AnalyticsReporting.v4.Data.GetReportsRequest body)
                : base(service)
            {
                Body = body;
                InitParameters();
            }



            /// <summary>Gets or sets the body of this request.</summary>
            Google.Apis.AnalyticsReporting.v4.Data.GetReportsRequest Body { get; set; }

            ///<summary>Returns the body of the request.</summary>
            protected override object GetBody() { return Body; }

            ///<summary>Gets the method name.</summary>
            public override string MethodName
            {
                get { return "batchGet"; }
            }

            ///<summary>Gets the HTTP method.</summary>
            public override string HttpMethod
            {
                get { return "POST"; }
            }

            ///<summary>Gets the REST path.</summary>
            public override string RestPath
            {
                get { return "v4/reports:batchGet"; }
            }

            /// <summary>Initializes BatchGet parameter list.</summary>
            protected override void InitParameters()
            {
                base.InitParameters();

            }

        }
    }
}

namespace Google.Apis.AnalyticsReporting.v4.Data
{    

    /// <summary>Defines a cohort. A cohort is a group of users who share a common characteristic. For example, all
    /// users with the same acquisition date belong to the same cohort.</summary>
    public class Cohort : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>This is used for `FIRST_VISIT_DATE` cohort, the cohort selects users whose first visit date is
        /// between start date and end date defined in the DateRange. The date ranges should be aligned for cohort
        /// requests. If the request contains `ga:cohortNthDay` it should be exactly one day long, if `ga:cohortNthWeek`
        /// it should be aligned to the week boundary (starting at Sunday and ending Saturday), and for
        /// `ga:cohortNthMonth` the date range should be aligned to the month (starting at the first and ending on the
        /// last day of the month). For LTV requests there are no such restrictions. You do not need to supply a date
        /// range for the `reportsRequest.dateRanges` field.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("dateRange")]
        public virtual DateRange DateRange { get; set; } 

        /// <summary>A unique name for the cohort. If not defined name will be auto-generated with values
        /// cohort_[1234...].</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("name")]
        public virtual string Name { get; set; } 

        /// <summary>Type of the cohort. The only supported type as of now is `FIRST_VISIT_DATE`. If this field is
        /// unspecified the cohort is treated as `FIRST_VISIT_DATE` type cohort.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("type")]
        public virtual string Type { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Defines a cohort group. For example:
    ///
    /// "cohortGroup": { "cohorts": [{ "name": "cohort 1", "type": "FIRST_VISIT_DATE", "dateRange": { "startDate":
    /// "2015-08-01", "endDate": "2015-08-01" } },{ "name": "cohort 2" "type": "FIRST_VISIT_DATE" "dateRange": {
    /// "startDate": "2015-07-01", "endDate": "2015-07-01" } }] }</summary>
    public class CohortGroup : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>The definition for the cohort.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("cohorts")]
        public virtual System.Collections.Generic.IList<Cohort> Cohorts { get; set; } 

        /// <summary>Enable Life Time Value (LTV).  LTV measures lifetime value for users acquired through different
        /// channels. Please see: [Cohort Analysis](https://support.google.com/analytics/answer/6074676) and [Lifetime
        /// Value](https://support.google.com/analytics/answer/6182550) If the value of lifetimeValue is false:
        ///
        /// - The metric values are similar to the values in the web interface cohort report. - The cohort definition
        /// date ranges must be aligned to the calendar week and month. i.e. while requesting `ga:cohortNthWeek` the
        /// `startDate` in the cohort definition should be a Sunday and the `endDate` should be the following Saturday,
        /// and for `ga:cohortNthMonth`, the `startDate` should be the 1st of the month and `endDate` should be the last
        /// day of the month.
        ///
        /// When the lifetimeValue is true:
        ///
        /// - The metric values will correspond to the values in the web interface LifeTime value report. - The Lifetime
        /// Value report shows you how user value (Revenue) and engagement (Appviews, Goal Completions, Sessions, and
        /// Session Duration) grow during the 90 days after a user is acquired. - The metrics are calculated as a
        /// cumulative average per user per the time increment. - The cohort definition date ranges need not be aligned
        /// to the calendar week and month boundaries. - The `viewId` must be an [app view
        /// ID](https://support.google.com/analytics/answer/2649553#WebVersusAppViews)</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("lifetimeValue")]
        public virtual System.Nullable<bool> LifetimeValue { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Column headers.</summary>
    public class ColumnHeader : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>The dimension names in the response.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("dimensions")]
        public virtual System.Collections.Generic.IList<string> Dimensions { get; set; } 

        /// <summary>Metric headers for the metrics in the response.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("metricHeader")]
        public virtual MetricHeader MetricHeader { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>A contiguous set of days: startDate, startDate + 1 day, ..., endDate. The start and end dates are
    /// specified in [ISO8601](https://en.wikipedia.org/wiki/ISO_8601) date format `YYYY-MM-DD`.</summary>
    public class DateRange : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>The end date for the query in the format `YYYY-MM-DD`.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("endDate")]
        public virtual string EndDate { get; set; } 

        /// <summary>The start date for the query in the format `YYYY-MM-DD`.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("startDate")]
        public virtual string StartDate { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Used to return a list of metrics for a single DateRange / dimension combination</summary>
    public class DateRangeValues : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>The values of each pivot region.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("pivotValueRegions")]
        public virtual System.Collections.Generic.IList<PivotValueRegion> PivotValueRegions { get; set; } 

        /// <summary>Each value corresponds to each Metric in the request.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("values")]
        public virtual System.Collections.Generic.IList<string> Values { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>[Dimensions](https://support.google.com/analytics/answer/1033861) are attributes of your data. For
    /// example, the dimension `ga:city` indicates the city, for example, "Paris" or "New York", from which a session
    /// originates.</summary>
    public class Dimension : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>If non-empty, we place dimension values into buckets after string to int64. Dimension values that
        /// are not the string representation of an integral value will be converted to zero.  The bucket values have to
        /// be in increasing order.  Each bucket is closed on the lower end, and open on the upper end. The "first"
        /// bucket includes all values less than the first boundary, the "last" bucket includes all values up to
        /// infinity. Dimension values that fall in a bucket get transformed to a new dimension value. For example, if
        /// one gives a list of "0, 1, 3, 4, 7", then we return the following buckets:
        ///
        /// - bucket #1: values < 0, dimension value "<0" - bucket #2: values in [0,1), dimension value "0" - bucket #3:
        /// values in [1,3), dimension value "1-2" - bucket #4: values in [3,4), dimension value "3" - bucket #5: values
        /// in [4,7), dimension value "4-6" - bucket #6: values >= 7, dimension value "7+"
        ///
        /// NOTE: If you are applying histogram mutation on any dimension, and using that dimension in sort, you will
        /// want to use the sort type `HISTOGRAM_BUCKET` for that purpose. Without that the dimension values will be
        /// sorted according to dictionary (lexicographic) order. For example the ascending dictionary order is:
        ///
        /// "<50", "1001+", "121-1000", "50-120"
        ///
        /// And the ascending `HISTOGRAM_BUCKET` order is:
        ///
        /// "<50", "50-120", "121-1000", "1001+"
        ///
        /// The client has to explicitly request `"orderType": "HISTOGRAM_BUCKET"` for a histogram-mutated
        /// dimension.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("histogramBuckets")]
        public virtual System.Collections.Generic.IList<System.Nullable<long>> HistogramBuckets { get; set; } 

        /// <summary>Name of the dimension to fetch, for example `ga:browser`.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("name")]
        public virtual string Name { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Dimension filter specifies the filtering options on a dimension.</summary>
    public class DimensionFilter : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>Should the match be case sensitive? Default is false.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("caseSensitive")]
        public virtual System.Nullable<bool> CaseSensitive { get; set; } 

        /// <summary>The dimension to filter on. A DimensionFilter must contain a dimension.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("dimensionName")]
        public virtual string DimensionName { get; set; } 

        /// <summary>Strings or regular expression to match against. Only the first value of the list is used for
        /// comparison unless the operator is `IN_LIST`. If `IN_LIST` operator, then the entire list is used to filter
        /// the dimensions as explained in the description of the `IN_LIST` operator.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("expressions")]
        public virtual System.Collections.Generic.IList<string> Expressions { get; set; } 

        /// <summary>Logical `NOT` operator. If this boolean is set to true, then the matching dimension values will be
        /// excluded in the report. The default is false.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("not")]
        public virtual System.Nullable<bool> Not { get; set; } 

        /// <summary>How to match the dimension to the expression. The default is REGEXP.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("operator")]
        public virtual string Operator__ { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>A group of dimension filters. Set the operator value to specify how the filters are logically
    /// combined.</summary>
    public class DimensionFilterClause : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>The repeated set of filters. They are logically combined based on the operator specified.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("filters")]
        public virtual System.Collections.Generic.IList<DimensionFilter> Filters { get; set; } 

        /// <summary>The operator for combining multiple dimension filters. If unspecified, it is treated as an
        /// `OR`.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("operator")]
        public virtual string Operator__ { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Dynamic segment definition for defining the segment within the request. A segment can select users,
    /// sessions or both.</summary>
    public class DynamicSegment : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>The name of the dynamic segment.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("name")]
        public virtual string Name { get; set; } 

        /// <summary>Session Segment to select sessions to include in the segment.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("sessionSegment")]
        public virtual SegmentDefinition SessionSegment { get; set; } 

        /// <summary>User Segment to select users to include in the segment.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("userSegment")]
        public virtual SegmentDefinition UserSegment { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>The batch request containing multiple report request.</summary>
    public class GetReportsRequest : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>Requests, each request will have a separate response. There can be a maximum of 5 requests. All
        /// requests should have the same `dateRanges`, `viewId`, `segments`, `samplingLevel`, and
        /// `cohortGroup`.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("reportRequests")]
        public virtual System.Collections.Generic.IList<ReportRequest> ReportRequests { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>The main response class which holds the reports from the Reporting API `batchGet` call.</summary>
    public class GetReportsResponse : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>Responses corresponding to each of the request.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("reports")]
        public virtual System.Collections.Generic.IList<Report> Reports { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>[Metrics](https://support.google.com/analytics/answer/1033861) are the quantitative measurements. For
    /// example, the metric `ga:users` indicates the total number of users for the requested time period.</summary>
    public class Metric : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>An alias for the metric expression is an alternate name for the expression. The alias can be used
        /// for filtering and sorting. This field is optional and is useful if the expression is not a single metric but
        /// a complex expression which cannot be used in filtering and sorting. The alias is also used in the response
        /// column header.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("alias")]
        public virtual string Alias { get; set; } 

        /// <summary>A metric expression in the request. An expression is constructed from one or more metrics and
        /// numbers. Accepted operators include: Plus (+), Minus (-), Negation (Unary -), Divided by (/), Multiplied by
        /// (*), Parenthesis, Positive cardinal numbers (0-9), can include decimals and is limited to 1024 characters.
        /// Example `ga:totalRefunds/ga:users`, in most cases the metric expression is just a single metric name like
        /// `ga:users`. Adding mixed `MetricType` (E.g., `CURRENCY` + `PERCENTAGE`) metrics will result in unexpected
        /// results.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("expression")]
        public virtual string Expression { get; set; } 

        /// <summary>Specifies how the metric expression should be formatted, for example `INTEGER`.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("formattingType")]
        public virtual string FormattingType { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>MetricFilter specifies the filter on a metric.</summary>
    public class MetricFilter : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>The value to compare against.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("comparisonValue")]
        public virtual string ComparisonValue { get; set; } 

        /// <summary>The metric that will be filtered on. A metricFilter must contain a metric name. A metric name can
        /// be an alias earlier defined as a metric or it can also be a metric expression.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("metricName")]
        public virtual string MetricName { get; set; } 

        /// <summary>Logical `NOT` operator. If this boolean is set to true, then the matching metric values will be
        /// excluded in the report. The default is false.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("not")]
        public virtual System.Nullable<bool> Not { get; set; } 

        /// <summary>Is the metric `EQUAL`, `LESS_THAN` or `GREATER_THAN` the comparisonValue, the default is `EQUAL`.
        /// If the operator is `IS_MISSING`, checks if the metric is missing and would ignore the
        /// comparisonValue.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("operator")]
        public virtual string Operator__ { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Represents a group of metric filters. Set the operator value to specify how the filters are logically
    /// combined.</summary>
    public class MetricFilterClause : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>The repeated set of filters. They are logically combined based on the operator specified.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("filters")]
        public virtual System.Collections.Generic.IList<MetricFilter> Filters { get; set; } 

        /// <summary>The operator for combining multiple metric filters. If unspecified, it is treated as an
        /// `OR`.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("operator")]
        public virtual string Operator__ { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>The headers for the metrics.</summary>
    public class MetricHeader : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>Headers for the metrics in the response.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("metricHeaderEntries")]
        public virtual System.Collections.Generic.IList<MetricHeaderEntry> MetricHeaderEntries { get; set; } 

        /// <summary>Headers for the pivots in the response.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("pivotHeaders")]
        public virtual System.Collections.Generic.IList<PivotHeader> PivotHeaders { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Header for the metrics.</summary>
    public class MetricHeaderEntry : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>The name of the header.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("name")]
        public virtual string Name { get; set; } 

        /// <summary>The type of the metric, for example `INTEGER`.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("type")]
        public virtual string Type { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>A list of segment filters in the `OR` group are combined with the logical OR operator.</summary>
    public class OrFiltersForSegment : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>List of segment filters to be combined with a `OR` operator.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("segmentFilterClauses")]
        public virtual System.Collections.Generic.IList<SegmentFilterClause> SegmentFilterClauses { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Specifies the sorting options.</summary>
    public class OrderBy : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>The field which to sort by. The default sort order is ascending. Example: `ga:browser`. Note, that
        /// you can only specify one field for sort here. For example, `ga:browser, ga:city` is not valid.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("fieldName")]
        public virtual string FieldName { get; set; } 

        /// <summary>The order type. The default orderType is `VALUE`.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("orderType")]
        public virtual string OrderType { get; set; } 

        /// <summary>The sorting order for the field.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("sortOrder")]
        public virtual string SortOrder { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>The Pivot describes the pivot section in the request. The Pivot helps rearrange the information in the
    /// table for certain reports by pivoting your data on a second dimension.</summary>
    public class Pivot : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>DimensionFilterClauses are logically combined with an `AND` operator: only data that is included by
        /// all these DimensionFilterClauses contributes to the values in this pivot region. Dimension filters can be
        /// used to restrict the columns shown in the pivot region. For example if you have `ga:browser` as the
        /// requested dimension in the pivot region, and you specify key filters to restrict `ga:browser` to only "IE"
        /// or "Firefox", then only those two browsers would show up as columns.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("dimensionFilterClauses")]
        public virtual System.Collections.Generic.IList<DimensionFilterClause> DimensionFilterClauses { get; set; } 

        /// <summary>A list of dimensions to show as pivot columns. A Pivot can have a maximum of 4 dimensions. Pivot
        /// dimensions are part of the restriction on the total number of dimensions allowed in the request.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("dimensions")]
        public virtual System.Collections.Generic.IList<Dimension> Dimensions { get; set; } 

        /// <summary>Specifies the maximum number of groups to return. The default value is 10, also the maximum value
        /// is 1,000.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("maxGroupCount")]
        public virtual System.Nullable<int> MaxGroupCount { get; set; } 

        /// <summary>The pivot metrics. Pivot metrics are part of the restriction on total number of metrics allowed in
        /// the request.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("metrics")]
        public virtual System.Collections.Generic.IList<Metric> Metrics { get; set; } 

        /// <summary>If k metrics were requested, then the response will contain some data-dependent multiple of k
        /// columns in the report.  E.g., if you pivoted on the dimension `ga:browser` then you'd get k columns for
        /// "Firefox", k columns for "IE", k columns for "Chrome", etc. The ordering of the groups of columns is
        /// determined by descending order of "total" for the first of the k values.  Ties are broken by lexicographic
        /// ordering of the first pivot dimension, then lexicographic ordering of the second pivot dimension, and so on.
        /// E.g., if the totals for the first value for Firefox, IE, and Chrome were 8, 2, 8, respectively, the order of
        /// columns would be Chrome, Firefox, IE.
        ///
        /// The following let you choose which of the groups of k columns are included in the response.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("startGroup")]
        public virtual System.Nullable<int> StartGroup { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>The headers for each of the pivot sections defined in the request.</summary>
    public class PivotHeader : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>A single pivot section header.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("pivotHeaderEntries")]
        public virtual System.Collections.Generic.IList<PivotHeaderEntry> PivotHeaderEntries { get; set; } 

        /// <summary>The total number of groups for this pivot.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("totalPivotGroupsCount")]
        public virtual System.Nullable<int> TotalPivotGroupsCount { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>The headers for the each of the metric column corresponding to the metrics requested in the pivots
    /// section of the response.</summary>
    public class PivotHeaderEntry : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>The name of the dimensions in the pivot response.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("dimensionNames")]
        public virtual System.Collections.Generic.IList<string> DimensionNames { get; set; } 

        /// <summary>The values for the dimensions in the pivot.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("dimensionValues")]
        public virtual System.Collections.Generic.IList<string> DimensionValues { get; set; } 

        /// <summary>The metric header for the metric in the pivot.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("metric")]
        public virtual MetricHeaderEntry Metric { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>The metric values in the pivot region.</summary>
    public class PivotValueRegion : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>The values of the metrics in each of the pivot regions.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("values")]
        public virtual System.Collections.Generic.IList<string> Values { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>The data response corresponding to the request.</summary>
    public class Report : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>The column headers.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("columnHeader")]
        public virtual ColumnHeader ColumnHeader { get; set; } 

        /// <summary>Response data.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("data")]
        public virtual ReportData Data { get; set; } 

        /// <summary>Page token to retrieve the next page of results in the list.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("nextPageToken")]
        public virtual string NextPageToken { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>The data part of the report.</summary>
    public class ReportData : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>The last time the data in the report was refreshed. All the hits received before this timestamp are
        /// included in the calculation of the report.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("dataLastRefreshed")]
        public virtual object DataLastRefreshed { get; set; } 

        /// <summary>Indicates if response to this request is golden or not. Data is golden when the exact same request
        /// will not produce any new results if asked at a later point in time.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("isDataGolden")]
        public virtual System.Nullable<bool> IsDataGolden { get; set; } 

        /// <summary>Minimum and maximum values seen over all matching rows. These are both empty when `hideValueRanges`
        /// in the request is false, or when rowCount is zero.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("maximums")]
        public virtual System.Collections.Generic.IList<DateRangeValues> Maximums { get; set; } 

        /// <summary>Minimum and maximum values seen over all matching rows. These are both empty when `hideValueRanges`
        /// in the request is false, or when rowCount is zero.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("minimums")]
        public virtual System.Collections.Generic.IList<DateRangeValues> Minimums { get; set; } 

        /// <summary>Total number of matching rows for this query.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("rowCount")]
        public virtual System.Nullable<int> RowCount { get; set; } 

        /// <summary>There's one ReportRow for every unique combination of dimensions.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("rows")]
        public virtual System.Collections.Generic.IList<ReportRow> Rows { get; set; } 

        /// <summary>If the results are [sampled](https://support.google.com/analytics/answer/2637192), this returns the
        /// total number of samples read, one entry per date range. If the results are not sampled this field will not
        /// be defined. See [developer guide](/analytics/devguides/reporting/core/v4/basics#sampling) for
        /// details.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("samplesReadCounts")]
        public virtual System.Collections.Generic.IList<System.Nullable<long>> SamplesReadCounts { get; set; } 

        /// <summary>If the results are [sampled](https://support.google.com/analytics/answer/2637192), this returns the
        /// total number of samples present, one entry per date range. If the results are not sampled this field will
        /// not be defined. See [developer guide](/analytics/devguides/reporting/core/v4/basics#sampling) for
        /// details.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("samplingSpaceSizes")]
        public virtual System.Collections.Generic.IList<System.Nullable<long>> SamplingSpaceSizes { get; set; } 

        /// <summary>For each requested date range, for the set of all rows that match the query, every requested value
        /// format gets a total. The total for a value format is computed by first totaling the metrics mentioned in the
        /// value format and then evaluating the value format as a scalar expression.  E.g., The "totals" for `3 /
        /// (ga:sessions + 2)` we compute `3 / ((sum of all relevant ga:sessions) + 2)`. Totals are computed before
        /// pagination.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("totals")]
        public virtual System.Collections.Generic.IList<DateRangeValues> Totals { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>The main request class which specifies the Reporting API request.</summary>
    public class ReportRequest : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>Cohort group associated with this request. If there is a cohort group in the request the
        /// `ga:cohort` dimension must be present. Every [ReportRequest](#ReportRequest) within a `batchGet` method must
        /// contain the same `cohortGroup` definition.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("cohortGroup")]
        public virtual CohortGroup CohortGroup { get; set; } 

        /// <summary>Date ranges in the request. The request can have a maximum of 2 date ranges. The response will
        /// contain a set of metric values for each combination of the dimensions for each date range in the request.
        /// So, if there are two date ranges, there will be two set of metric values, one for the original date range
        /// and one for the second date range. The `reportRequest.dateRanges` field should not be specified for cohorts
        /// or Lifetime value requests. If a date range is not provided, the default date range is (startDate: current
        /// date - 7 days, endDate: current date - 1 day). Every [ReportRequest](#ReportRequest) within a `batchGet`
        /// method must contain the same `dateRanges` definition.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("dateRanges")]
        public virtual System.Collections.Generic.IList<DateRange> DateRanges { get; set; } 

        /// <summary>The dimension filter clauses for filtering Dimension Values. They are logically combined with the
        /// `AND` operator. Note that filtering occurs before any dimensions are aggregated, so that the returned
        /// metrics represent the total for only the relevant dimensions.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("dimensionFilterClauses")]
        public virtual System.Collections.Generic.IList<DimensionFilterClause> DimensionFilterClauses { get; set; } 

        /// <summary>The dimensions requested. Requests can have a total of 7 dimensions.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("dimensions")]
        public virtual System.Collections.Generic.IList<Dimension> Dimensions { get; set; } 

        /// <summary>Dimension or metric filters that restrict the data returned for your request. To use the
        /// `filtersExpression`, supply a dimension or metric on which to filter, followed by the filter expression. For
        /// example, the following expression selects `ga:browser` dimension which starts with Firefox;
        /// `ga:browser=~^Firefox`. For more information on dimensions and metric filters, see [Filters
        /// reference](https://developers.google.com/analytics/devguides/reporting/core/v3/reference#filters).</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("filtersExpression")]
        public virtual string FiltersExpression { get; set; } 

        /// <summary>If set to true, hides the total of all metrics for all the matching rows, for every date range. The
        /// default false and will return the totals.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("hideTotals")]
        public virtual System.Nullable<bool> HideTotals { get; set; } 

        /// <summary>If set to true, hides the minimum and maximum across all matching rows. The default is false and
        /// the value ranges are returned.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("hideValueRanges")]
        public virtual System.Nullable<bool> HideValueRanges { get; set; } 

        /// <summary>If set to false, the response does not include rows if all the retrieved metrics are equal to zero.
        /// The default is false which will exclude these rows.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("includeEmptyRows")]
        public virtual System.Nullable<bool> IncludeEmptyRows { get; set; } 

        /// <summary>The metric filter clauses. They are logically combined with the `AND` operator.  Metric filters
        /// look at only the first date range and not the comparing date range. Note that filtering on metrics occurs
        /// after the metrics are aggregated.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("metricFilterClauses")]
        public virtual System.Collections.Generic.IList<MetricFilterClause> MetricFilterClauses { get; set; } 

        /// <summary>The metrics requested. Requests must specify at least one metric. Requests can have a total of 10
        /// metrics.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("metrics")]
        public virtual System.Collections.Generic.IList<Metric> Metrics { get; set; } 

        /// <summary>Sort order on output rows. To compare two rows, the elements of the following are applied in order
        /// until a difference is found.  All date ranges in the output get the same row order.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("orderBys")]
        public virtual System.Collections.Generic.IList<OrderBy> OrderBys { get; set; } 

        /// <summary>Page size is for paging and specifies the maximum number of returned rows. Page size should be >=
        /// 0. A query returns the default of 1,000 rows. The Analytics Core Reporting API returns a maximum of 10,000
        /// rows per request, no matter how many you ask for. It can also return fewer rows than requested, if there
        /// aren't as many dimension segments as you expect. For instance, there are fewer than 300 possible values for
        /// `ga:country`, so when segmenting only by country, you can't get more than 300 rows, even if you set
        /// `pageSize` to a higher value.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("pageSize")]
        public virtual System.Nullable<int> PageSize { get; set; } 

        /// <summary>A continuation token to get the next page of the results. Adding this to the request will return
        /// the rows after the pageToken. The pageToken should be the value returned in the nextPageToken parameter in
        /// the response to the GetReports request.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("pageToken")]
        public virtual string PageToken { get; set; } 

        /// <summary>The pivot definitions. Requests can have a maximum of 2 pivots.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("pivots")]
        public virtual System.Collections.Generic.IList<Pivot> Pivots { get; set; } 

        /// <summary>The desired report [sample](https://support.google.com/analytics/answer/2637192) size. If the the
        /// `samplingLevel` field is unspecified the `DEFAULT` sampling level is used. Every
        /// [ReportRequest](#ReportRequest) within a `batchGet` method must contain the same `samplingLevel` definition.
        /// See [developer guide](/analytics/devguides/reporting/core/v4/basics#sampling) for details.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("samplingLevel")]
        public virtual string SamplingLevel { get; set; } 

        /// <summary>Segment the data returned for the request. A segment definition helps look at a subset of the
        /// segment request. A request can contain up to four segments. Every [ReportRequest](#ReportRequest) within a
        /// `batchGet` method must contain the same `segments` definition. Requests with segments must have the
        /// `ga:segment` dimension.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("segments")]
        public virtual System.Collections.Generic.IList<Segment> Segments { get; set; } 

        /// <summary>The Analytics [view ID](https://support.google.com/analytics/answer/1009618) from which to retrieve
        /// data. Every [ReportRequest](#ReportRequest) within a `batchGet` method must contain the same
        /// `viewId`.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("viewId")]
        public virtual string ViewId { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>A row in the report.</summary>
    public class ReportRow : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>List of requested dimensions.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("dimensions")]
        public virtual System.Collections.Generic.IList<string> Dimensions { get; set; } 

        /// <summary>List of metrics for each requested DateRange.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("metrics")]
        public virtual System.Collections.Generic.IList<DateRangeValues> Metrics { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>The segment definition, if the report needs to be segmented. A Segment is a subset of the Analytics
    /// data. For example, of the entire set of users, one Segment might be users from a particular country or
    /// city.</summary>
    public class Segment : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>A dynamic segment definition in the request.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("dynamicSegment")]
        public virtual DynamicSegment DynamicSegment { get; set; } 

        /// <summary>The segment ID of a built-in or custom segment, for example `gaid::-3`.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("segmentId")]
        public virtual string SegmentId { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>SegmentDefinition defines the segment to be a set of SegmentFilters which are combined together with a
    /// logical `AND` operation.</summary>
    public class SegmentDefinition : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>A segment is defined by a set of segment filters which are combined together with a logical `AND`
        /// operation.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("segmentFilters")]
        public virtual System.Collections.Generic.IList<SegmentFilter> SegmentFilters { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Dimension filter specifies the filtering options on a dimension.</summary>
    public class SegmentDimensionFilter : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>Should the match be case sensitive, ignored for `IN_LIST` operator.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("caseSensitive")]
        public virtual System.Nullable<bool> CaseSensitive { get; set; } 

        /// <summary>Name of the dimension for which the filter is being applied.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("dimensionName")]
        public virtual string DimensionName { get; set; } 

        /// <summary>The list of expressions, only the first element is used for all operators</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("expressions")]
        public virtual System.Collections.Generic.IList<string> Expressions { get; set; } 

        /// <summary>Maximum comparison values for `BETWEEN` match type.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("maxComparisonValue")]
        public virtual string MaxComparisonValue { get; set; } 

        /// <summary>Minimum comparison values for `BETWEEN` match type.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("minComparisonValue")]
        public virtual string MinComparisonValue { get; set; } 

        /// <summary>The operator to use to match the dimension with the expressions.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("operator")]
        public virtual string Operator__ { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>SegmentFilter defines the segment to be either a simple or a sequence segment. A simple segment
    /// condition contains dimension and metric conditions to select the sessions or users. A sequence segment condition
    /// can be used to select users or sessions based on sequential conditions.</summary>
    public class SegmentFilter : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>If true, match the complement of simple or sequence segment. For example, to match all visits not
        /// from "New York", we can define the segment as follows:
        ///
        /// "sessionSegment": { "segmentFilters": [{ "simpleSegment" :{ "orFiltersForSegment": [{
        /// "segmentFilterClauses":[{ "dimensionFilter": { "dimensionName": "ga:city", "expressions": ["New York"] } }]
        /// }] }, "not": "True" }] },</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("not")]
        public virtual System.Nullable<bool> Not { get; set; } 

        /// <summary>Sequence conditions consist of one or more steps, where each step is defined by one or more
        /// dimension/metric conditions. Multiple steps can be combined with special sequence operators.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("sequenceSegment")]
        public virtual SequenceSegment SequenceSegment { get; set; } 

        /// <summary>A Simple segment conditions consist of one or more dimension/metric conditions that can be
        /// combined</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("simpleSegment")]
        public virtual SimpleSegment SimpleSegment { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Filter Clause to be used in a segment definition, can be wither a metric or a dimension
    /// filter.</summary>
    public class SegmentFilterClause : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>Dimension Filter for the segment definition.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("dimensionFilter")]
        public virtual SegmentDimensionFilter DimensionFilter { get; set; } 

        /// <summary>Metric Filter for the segment definition.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("metricFilter")]
        public virtual SegmentMetricFilter MetricFilter { get; set; } 

        /// <summary>Matches the complement (`!`) of the filter.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("not")]
        public virtual System.Nullable<bool> Not { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Metric filter to be used in a segment filter clause.</summary>
    public class SegmentMetricFilter : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>The value to compare against. If the operator is `BETWEEN`, this value is treated as minimum
        /// comparison value.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("comparisonValue")]
        public virtual string ComparisonValue { get; set; } 

        /// <summary>Max comparison value is only used for `BETWEEN` operator.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("maxComparisonValue")]
        public virtual string MaxComparisonValue { get; set; } 

        /// <summary>The metric that will be filtered on. A `metricFilter` must contain a metric name.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("metricName")]
        public virtual string MetricName { get; set; } 

        /// <summary>Specifies is the operation to perform to compare the metric. The default is `EQUAL`.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("operator")]
        public virtual string Operator__ { get; set; } 

        /// <summary>Scope for a metric defines the level at which that metric is defined.  The specified metric scope
        /// must be equal to or greater than its primary scope as defined in the data model. The primary scope is
        /// defined by if the segment is selecting users or sessions.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("scope")]
        public virtual string Scope { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>A segment sequence definition.</summary>
    public class SegmentSequenceStep : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>Specifies if the step immediately precedes or can be any time before the next step.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("matchType")]
        public virtual string MatchType { get; set; } 

        /// <summary>A sequence is specified with a list of Or grouped filters which are combined with `AND`
        /// operator.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("orFiltersForSegment")]
        public virtual System.Collections.Generic.IList<OrFiltersForSegment> OrFiltersForSegment { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Sequence conditions consist of one or more steps, where each step is defined by one or more
    /// dimension/metric conditions. Multiple steps can be combined with special sequence operators.</summary>
    public class SequenceSegment : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>If set, first step condition must match the first hit of the visitor (in the date range).</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("firstStepShouldMatchFirstHit")]
        public virtual System.Nullable<bool> FirstStepShouldMatchFirstHit { get; set; } 

        /// <summary>The list of steps in the sequence.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("segmentSequenceSteps")]
        public virtual System.Collections.Generic.IList<SegmentSequenceStep> SegmentSequenceSteps { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>A Simple segment conditions consist of one or more dimension/metric conditions that can be
    /// combined.</summary>
    public class SimpleSegment : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>A list of segment filters groups which are combined with logical `AND` operator.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("orFiltersForSegment")]
        public virtual System.Collections.Generic.IList<OrFiltersForSegment> OrFiltersForSegment { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }
}
